python数据类型（三）

python的组合数据类型，包括集合、列表、元组、字典

组合数据类型：包含一组数据且作为单一管理结构的数据类型

顺序性：一组数据以无序或有序方式组织
一致性：一组数据以相同或不同的类型组织
索引性：一组数据能否以及采用序号或自定义索引方式组织

3大类7小类

集合（无序、非一致，无索引）：可变集合（set）、不可变集合（frozenset）
序列（有序、非一致/一致、序号索引）：元组、列表、字符串、字节串
字典（无序、非一致、自定义索引）：字典

集合

多个元素的无序组合
元素类型可以不同，但必须可哈希，即不可变类型
集合中无重复的元素
不能对某个元素进行定点索引，可以遍历或随机获取元素
可变集合使用大括号{}表示，元素间用逗号分隔，建立集合使用{}或set()函数。如 a = {1,2,3,3,’a’}
不可变集合用frozenset()函数创建，表示为frozenset({ })形式，接收一个可迭代的对象

集合操作符

操作符	含义
in	元素判断
not in	元素判断
&	返回交集
\		返回并集
-	返回差集
^	返回补给
<	真子集判断
<=	子集判断
>	真超集判断
>=	超集判断
==	全形同判断
!=	不相同判断

集合操作函数

函数	含义
len(x)	返回集合的元素个数
set(x)	转换组合类型，创建一个集合

集合操作方法

方法	含义
set.add(x)	添加x到集合
set.remove(x)	删除set中的元素x，如果x不存在，产生KeyError
set.discard(x)	删除set中的元素x，如果x不存在，不报错
set.clear()	清空集合
set.pop()	随机弹出一个元素，如果集合为空，产生KeyError
set.copy()	复制集合，产生一个新副本
set.intersection(x)	集合的交集，返回新集合，不更新set
set.union(x)	集合的并集，返回新集合，不更新set
set.difference(x)	集合的差集，返回新集合，不更新set
set.symmetric_difference()	集合的补集，返回新集合，不更新set
set.intersection_update(x)	集合的交集，更新原集合
set.update(x)	集合的并集，更新原集合
set.difference_update (x)	集合的差集，更新原集合
set.symmetric_difference_update ()	集合的补集，更新原集合
set.isdisjoint(x)	无关判断，两个集合之间无共同元素则返回True
set.issubset(x)	子集判断，如果x是集合的子集则返回True
set.issuperset(x)	超集判断，如果x是集合的超集则返回True

1
2
3

# 利用集合实现数据去重
li = [1,2,1,4,6,3,2,0]
li = list(set(li)) # [0, 1, 2, 3, 4, 6]

不可变集合

frozenset(iterable)

字典

可变类型

字典类型是键值对的集合，反映了数据之间的映射关系（键(索引)和值(数据)的对应）
元素间不存在顺序

字典使用大括号{}表示，键值间用冒号分隔，键值对间用逗号分隔

  d = dict()
  d = {"中国":"北京" , "美国":"华盛顿" , "法国":"巴黎"}
  d['中国'] == "北京"
  d.get('中国', 0) == "北京"
  d.get('德国', '不知道') =='不知道'

  - 具有极快的查找速度,不会随着key的增加而变慢

  - 需要占用大量的内存，内存浪费多。【空间换取时间】

  - 为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

    第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

  - 定义

    key必须是**不可变对象**，通过key计算位置的算法称为哈希算法（Hash）

    ~~~python
    d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    d = dict()
    d = dict(a = 3,b = 4)

    dict([(1,2),(3,4)]) #{1: 2, 3: 4}
    dict(zip(keys,values))
    ~~~

  - 访问/修改元素

    ~~~python
    d[key] # 如果key不存在，dict就会报错
    d[key] = newValue #一个key对应一个value，对一个key放入value，新值会把旧值冲掉
    ~~~

  - 判断key是否存在

    ~~~python
    'Bob' in d == True
    'Tom' in d == False
    d.get('Bob') == 75
    d.get('Tom') == None
    d.get('Tom', -1) == -1 # 设置默认值
    ~~~

  - 添加元素

    ~~~python
    d[newKey] = newValue
    ~~~

  - 弹出【删除并返回】一个key

    ~~~python
    d.pop('Bob') #返回75
    ~~~

  - 删除元素

    ~~~python
    del d[key]
    ~~~

  - 清空字典

    ~~~python
    d.clear()
    ~~~

字典**操作符**

| 操作符     | 含义                     |
| ---------- | ------------------------ |
| in, not in | 根据键的元素包含判断     |
| del        | 根据键删除字典中单个元素 |
| ==, !=     | 判断两个字典相同         |

字典操作**函数**

| 函数    | 含义                          |
| ------- | ----------------------------- |
| len(d)  | 返回字典的元素个数            |
| dict()  | 创建一个空字典                |
| iter(d) | 根据字典d的键形成一个迭代类型 |

字典操作**方法**

| 方法             | 含义                                                  |
| ---------------- | ----------------------------------------------------- |
| .items()         | 返回字典所有键值对，键值对采用(key,value)元组形式返回 |
| .keys()          | 返回字典的键                                          |
| .values()        | 返回字典的值                                          |
| .pop(k)          | 取出特定键k对应的值，并删除键值对                     |
| .popitem()       | 随机从字典中取出一个键值对，以(key,value)元组形式返回 |
| .update(t)       | 扩展其他字典t的内容到当前字典，键重复的替换           |
| .clear()         | 删除字典所有元素                                      |
| .copy()          | 拷贝字典中所有元素，生成一个新字典                    |
| .get(k, default) | 键k存在则返回对应值，否则返回default                  |



## 元组

<class 'tuple'>

不可变类型，可以被哈希

- 序列类型的一种，元素间的有序组合，一旦创建不能被修改

- 元组内的元素可以是不同类型

- 元组使用小括号()表示，元素间用逗号分隔，小括号可以省略。如：rgbcolor = 211, 11, 125

  ```python
  >>> a = tuple("pypy123")
  ('p', 'y', 'p', 'y', '1', '2', '3')
  >>> b = 123, 456
  (123, 456)

“可变的”tuple
1
2
3
4
5
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
元组指向哪些子对象不可更改，但被指向的子对象本身可以是可变的。

元组操作符

操作符	含义
in	元素判断
not in	元素判断
+	连接多个元组，返回一个新元组
*	重复元组多次，返回一个新元组
<,<=,>,>=,==,!=	按照顺序，逐个元素比较

只要元素比较得出True/False，则返回结果
比较时，元素间要有可比性 |

元组操作函数

函数	含义
len(x)	返回元组的元素个数
tuple(x)	转换组合类型，创建一个元组
min(x)	返回元组中最小的元素
max(x)	返回元组中最大的元素

元组操作方法

方法	含义
.index(x)	返回元组中第一次出现x的位置
.count(x)	返回元组中出现x的总次数

列表

可变类型

序列类型的一种，元素间的有序组合，类型不限，创建后可以随时被修改

列表使用中括号[]表示，元素间用逗号分隔，括号不可省略

>>> a = list("pypy123")
['p', 'y', 'p', 'y', '1', '2', '3']
>>> b = [123, 456]
[123, 456]

占用空间小，浪费内存很少。

列表操作符

操作符	含义
in, not in	元素判断
del	删除列表元素或列表片段
+	连接多个列表，返回一个新列表
*	重复列表多次，返回一个新列表
<,<=,>,>=,==,!=	按照顺序，逐个元素比较

只要元素比较得出True/False，则返回结果
比较时，元素间要有可比性 |

列表操作函数

函数	含义
len(x)	返回列表元素的个数
list(x)	转换组合类型，创建一个列表
min(x)	返回列表中最小的元素
max(x)	返回列表中最大的元素
sorted(x)	对列表元素以ASCII编码大小进行排序

列表操作方法

方法	含义
list.append(x)	在列表最后增加一个元素x
list.insert(i, x)	在列表第i位置增加元素x
list.extend(lt)	在列表最后增加一个新列表
list.remove()	删除列表中第一次出现的元素x
list.clear()	删除列表中所有元素
list.copy()	拷贝列表中所有元素，生成一个新列表
list.pop(i)	将列表第i位置元素取出并删除该元素
list.reverse()	列表中顺序元素反转
list.index(x)	返回列表中第一次出现x的位置
list.count(x)	返回列表中出现x的总次数
list.sort()	对列表进行排序，默认是值递增

定义列表

ll = list(range(5))
lan = ['php', 'java', 'c', 'c++', 'python']

[x * x for x in range(1, 11)] # 列表生成式，得到[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

[x * x for x in range(1, 11) if x % 2 == 0] # 列表生成式[4, 16, 36, 64, 100]

[m + n for m in 'ABC' for n in 'XYZ'] # 列表生成式，得到全排列['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

import os
[d for d in os.listdir('.')] # os.listdir可以列出文件和目录

d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

L = ['Hello', 'World', 'IBM', 'Apple']
[s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

1
2
3

a = [do(i) for i in iter] # ->等价于只有一个iter参数的map函数
a = [do(i) for i in iter if condition] # -> 等价于filter函数
a = [do(i,j) for i in iter1 if condition1 for j in iter2 if condition2] # 嵌套，全排列

1
2
3

'''练习 生成1 2 3 4 的全排列'''
a = [1,2,3,4]
b = [(i,j,x,y) for i in a for j in a for x in a for y in a]

访问/修改列表元素

len[0]  # 访问列表元素，结果是‘php’
l = ['a', 'b', True, 2.3, 4, [False, 3]]
l[5][1]  # 结果是3
lan[1] = 'r' # 修改
lan[-1]  # 访问列表中最后一个元素，结果是‘python’
lan[5]  # 索引越界，报错

添加列表元素

1
2
3

lan.append('.net')  # 追加元素
lan.insert(1, 'JavaScript') # 往指定位置插入元素
lan.extend([3,4,5])

弹出【删除并返回】列表元素

1 2	len.pop() # 弹出列表末尾元素 len.pop(0) # 弹出列表指定位置的元素

删除列表元素

1 2	del len[index] # 删除指定位置的元素 len.remove(content)

排序
1
len.sort()

反转

1 2	len.reverse() len[::-1]

>>>[]
[]
>>>[1,2,"1","2"]
[1, 2, '1', '2']
>>>ls = [1,2,"1","2", [1, 2, 3, 4]]
>>>ls[0]
1
>>>ls[-1]
[1, 2, 3, 4]
>>>ls[-1][-1]
4
>>>ls[0:3]
[1, 2, '1']
>>>ls[-4: -1]
[2, '1', '2']
>>>ls*2
[1, 2, '1', '2', [1, 2, 3, 4], 1, 2, '1', '2', [1, 2, 3, 4]]
>>>ls
[1, 2, '1', '2', [1, 2, 3, 4]]
>>>ls.append(5)
>>>ls
[1, 2, '1', '2', [1, 2, 3, 4], 5]
>>>ls.remove(ls[-1])
>>>ls
[1, 2, '1', '2', [1, 2, 3, 4]]
>>>len(ls)
5
>>>del ls[3]
>>>ls
[1, 2, '1', [1, 2, 3, 4]]
>>>ls[::-1]
[[1, 2, 3, 4], '1', 2, 1]
>>>ls.clear()
>>>ls
[]